///*******************************************************************************
// * Copyright (c) 2005, 2007 IBM Corporation and others.
// * All rights reserved. This program and the accompanying materials
// * are made available under the terms of the Eclipse Public License v1.0
// * which accompanies this distribution, and is available at
// * http://www.eclipse.org/legal/epl-v10.html
// *
// * Contributors:
// * IBM Corporation - initial API and implementation
// *******************************************************************************/
//
//package org.eclipse.ui.tests.operations;
//
//import java.io.BufferedReader;
//import java.io.ByteArrayInputStream;
//import java.io.IOException;
//import java.io.InputStream;
//import java.io.InputStreamReader;
//import java.net.URI;
//import java.text.MessageFormat;
//import java.util.ArrayList;
//import java.util.HashMap;
//import java.util.HashSet;
//import java.util.List;
//import java.util.Map;
//import java.util.Set;
//
//import org.eclipse.core.commands.ExecutionException;
//import org.eclipse.core.commands.operations.IOperationHistory;
//import org.eclipse.core.commands.operations.IUndoContext;
//import org.eclipse.core.filesystem.EFS;
//import org.eclipse.core.filesystem.IFileStore;
//import org.eclipse.core.filesystem.URIUtil;
//import org.eclipse.core.resources.IFile;
//import org.eclipse.core.resources.IFolder;
//import org.eclipse.core.resources.IMarker;
//import org.eclipse.core.resources.IProject;
//import org.eclipse.core.resources.IProjectDescription;
//import org.eclipse.core.resources.IResource;
//import org.eclipse.core.resources.IWorkspace;
//import org.eclipse.core.resources.IWorkspaceRoot;
//import org.eclipse.core.resources.ResourcesPlugin;
//import org.eclipse.core.runtime.CoreException;
//import org.eclipse.core.runtime.IPath;
//import org.eclipse.core.runtime.IProgressMonitor;
//import org.eclipse.core.runtime.IStatus;
//import org.eclipse.core.runtime.Path;
//import org.eclipse.core.tests.harness.FileSystemHelper;
//import org.eclipse.ui.PlatformUI;
//import org.eclipse.ui.ide.undo.AbstractWorkspaceOperation;
//import org.eclipse.ui.ide.undo.CopyProjectOperation;
//import org.eclipse.ui.ide.undo.CopyResourcesOperation;
//import org.eclipse.ui.ide.undo.CreateFileOperation;
//import org.eclipse.ui.ide.undo.CreateFolderOperation;
//import org.eclipse.ui.ide.undo.CreateMarkersOperation;
//import org.eclipse.ui.ide.undo.CreateProjectOperation;
//import org.eclipse.ui.ide.undo.DeleteMarkersOperation;
//import org.eclipse.ui.ide.undo.DeleteResourcesOperation;
//import org.eclipse.ui.ide.undo.MoveProjectOperation;
//import org.eclipse.ui.ide.undo.MoveResourcesOperation;
//import org.eclipse.ui.ide.undo.UpdateMarkersOperation;
//import org.eclipse.ui.internal.operations.AdvancedValidationUserApprover;
//import org.eclipse.ui.tests.harness.util.UITestCase;
//
///**
// * Tests the undo of various workspace operations. Uses the following workspace
// * structure to perform the tests
// *
// * <pre>
// * TEST_PROJECT_NAME
// * **TEST_FOLDER_NAME
// * ****TEST_SUBFOLDER_NAME
// * ******TEST_FILEINSUBFOLDER_NAME
// * ****TEST_EMPTYFILE_NAME
// * ****TEST_RANDOMFILE_NAME
// * ****TEST_LINKEDFILE_NAME (linked to random location)
// * ****TEST_LINKEDFOLDER_NAME (linked to random location)
// * **TEST_FILEINPROJECT_NAME
// * TEST_TARGETPROJECT_NAME
// * </pre>
// *
// * @since 3.3
// */
//public class WorkspaceOperationsTests extends UITestCase {
//
// IProject testProject, targetProject;
//
// IFolder testFolder, testSubFolder, testLinkedFolder;
//
// IFile emptyTestFile, testFileWithContent, testLinkedFile,
// testFileInSubFolder, testFileInProject;
//
// private final Set storesToDelete = new HashSet();
//
// IOperationHistory history;
//
// IUndoContext context;
//
// private static Map initialAttributes = new HashMap();
// static {
// initialAttributes.put("Attr1", "Attr1 1.0");
// initialAttributes.put("Attr2", "Attr2 1.0");
// initialAttributes.put("Attr3", "Attr3 1.0");
// initialAttributes.put("Attr4", "Attr4 1.0");
// initialAttributes.put("Attr5", "Attr5 1.0");
// initialAttributes.put("Attr6", "Attr6 1.0");
// };
//
// private static Map updatedAttributes = new HashMap();
// static {
// updatedAttributes.put("Attr1", "Attr1 1.1");
// updatedAttributes.put("Attr2", "Attr2 1.1");
// updatedAttributes.put("Attr3", "Attr3 1.1");
// updatedAttributes.put("Attr4", "Attr4 1.1");
// updatedAttributes.put("Attr5", "Attr5 1.1");
// updatedAttributes.put("Attr7", "Attr7 1.0");
// };
//
// private static Map mergedUpdatedAttributes = new HashMap();
// static {
// mergedUpdatedAttributes.put("Attr1", "Attr1 1.1");
// mergedUpdatedAttributes.put("Attr2", "Attr2 1.1");
// mergedUpdatedAttributes.put("Attr3", "Attr3 1.1");
// mergedUpdatedAttributes.put("Attr4", "Attr4 1.1");
// mergedUpdatedAttributes.put("Attr5", "Attr5 1.1");
// mergedUpdatedAttributes.put("Attr6", "Attr6 1.0");
// mergedUpdatedAttributes.put("Attr7", "Attr7 1.0");
// };
//
// private static List fileNameExcludes = new ArrayList();
// static {
// fileNameExcludes.add(".project");
// };
//
// private static String CUSTOM_TYPE = "TestMarkerType";
//
// private static String FILE_CONTENTS_EMPTY = "";
//
// private static String TEST_PROJECT_NAME = "WorkspaceOperationsTests_Project";
//
// private static String TEST_TARGET_PROJECT_NAME = "WorkspaceOperationsTests_MoveCopyTarget";
//
// private static String TEST_FOLDER_NAME = "WorkspaceOperationsTests_Folder";
//
// private static String TEST_SUBFOLDER_NAME = "WorkspaceOperationsTests_SubFolder";
//
// private static String TEST_LINKEDFOLDER_NAME = "WorkspaceOperationsTests_LinkedFolder";
//
// private static String TEST_LINKEDFILE_NAME = "WorkspaceOperationTests_LinkedFile";
//
// private static String TEST_EMPTYFILE_NAME = "WorkspaceOperationsTests_EmptyFile";
//
// private static String TEST_RANDOMFILE_NAME = "WorkspaceOperationsTests_RandomContentFile.txt";
//
// private static String TEST_FILEINPROJECT_NAME = "WorkspaceOperationsTests_FileInProject";
//
// private static String TEST_FILEINSUBFOLDER_NAME = "WorkspaceOperationsTests_FileInSubFolder";
//
// private static String TEST_NEWPROJECT_NAME = "WorkspaceOperationTests_NewProject";
//
// private static String TEST_NEWFOLDER_NAME = "WorkspaceOperationTests_NewFolder";
//
// private static String TEST_NEWFILE_NAME = "WorkspaceOperationTests_NewFile";
//
// private static String TEST_NEWNESTEDFOLDER_NAME = "scooby/dooby/doo/WorkspaceOperationTests_NewFolder";
//
// private static String TEST_NEWNESTEDFILE_NAME = "scooby/dooby/doo/WorkspaceOperationTests_NewFile";
//
// // Insider knowledge of WorkspaceUndoMonitor's change threshhold
// private static int NUM_CHANGES = 10;
//
// class FileSnapshot extends ResourceSnapshot {
// String content;
//
// URI location;
//
// MarkerSnapshot[] markerSnapshots;
//
// FileSnapshot(IFile file) throws CoreException {
// content = readContent(file);
// name = file.getName();
// if (file.isLinked()) {
// location = file.getLocationURI();
// }
// IMarker[] markers = file.findMarkers(null, true,
// IResource.DEPTH_INFINITE);
// markerSnapshots = new MarkerSnapshot[markers.length];
// for (int i = 0; i < markers.length; i++) {
// markerSnapshots[i] = new MarkerSnapshot(markers[i]);
// }
// }
//
// boolean isValid(IResource parent) throws CoreException {
// IResource resource = getWorkspaceRoot().findMember(
// parent.getFullPath().append(name));
// if (resource == null || !(resource instanceof IFile)) {
// return false;
// }
// IFile file = (IFile) resource;
// boolean contentMatch = readContent(file).equals(content);
// if (file.isLinked()) {
// contentMatch = contentMatch
// && file.getLocationURI().equals(location);
// }
// if (!contentMatch) {
// return false;
// }
// for (int i = 0; i < markerSnapshots.length; i++) {
// if (!markerSnapshots[i].existsOn(resource)) {
// return false;
// }
// }
// return true;
// }
// }
//
// class FolderSnapshot extends ResourceSnapshot {
// URI location;
//
// ResourceSnapshot[] memberSnapshots;
//
// FolderSnapshot(IFolder folder) throws CoreException {
// name = folder.getName();
// if (folder.isLinked()) {
// location = folder.getLocationURI();
// }
// IResource[] members = folder.members();
// memberSnapshots = new ResourceSnapshot[members.length];
// for (int i = 0; i < members.length; i++) {
// memberSnapshots[i] = snapshotFromResource(members[i]);
// }
// }
//
// boolean isValid(IResource parent) throws CoreException {
// IResource resource = getWorkspaceRoot().findMember(
// parent.getFullPath().append(name));
// if (resource == null || !(resource instanceof IFolder)) {
// return false;
// }
// IFolder folder = (IFolder) resource;
// if (folder.isLinked()) {
// if (!folder.getLocationURI().equals(location)) {
// return false;
// }
// }
// for (int i = 0; i < memberSnapshots.length; i++) {
// if (!fileNameExcludes.contains(memberSnapshots[i].name)) {
// if (!memberSnapshots[i].isValid(folder)) {
// return false;
// }
// }
// }
// return true;
// }
// }
//
// class MarkerSnapshot {
// String type;
//
// Map attributes;
//
// MarkerSnapshot(IMarker marker) throws CoreException {
// type = marker.getType();
// attributes = marker.getAttributes();
// }
//
// boolean existsOn(IResource resource) throws CoreException {
// // comparison is based on equality of attributes, since id will
// // change on create/delete/recreate sequence
// IMarker[] markers = resource.findMarkers(type, false,
// IResource.DEPTH_ZERO);
// for (int i = 0; i < markers.length; i++) {
// if (markers[i].getAttributes().equals(attributes)) {
// return true;
// }
// }
// return false;
// }
// }
//
// class ProjectSnapshot extends ResourceSnapshot {
// ResourceSnapshot[] memberSnapshots;
//
// ProjectSnapshot(IProject project) throws CoreException {
// name = project.getName();
// boolean open = project.isOpen();
// if (!open) {
// project.open(null);
// }
// IResource[] members = project.members();
// memberSnapshots = new ResourceSnapshot[members.length];
// for (int i = 0; i < members.length; i++) {
// memberSnapshots[i] = snapshotFromResource(members[i]);
// }
// if (!open) {
// project.close(null);
// }
//
// }
//
// boolean isValid(IResource parent) throws CoreException {
// IResource resource = getWorkspaceRoot().findMember(
// parent.getFullPath().append(name));
// if (resource == null || !(resource instanceof IProject)) {
// return false;
// }
// IProject project = (IProject) resource;
// // Must open it to validate the content
// boolean open = project.isOpen();
// if (!open) {
// project.open(null);
// }
//
// for (int i = 0; i < memberSnapshots.length; i++) {
// if (!fileNameExcludes.contains(memberSnapshots[i].name)) {
// if (!memberSnapshots[i].isValid(resource)) {
// return false;
// }
// }
// }
//
// if (!open) {
// project.close(null);
// }
//
// return true;
// }
//
// boolean isValid() throws CoreException {
// return isValid(getWorkspaceRoot());
// }
// }
//
// abstract class ResourceSnapshot {
// String name;
//
// abstract boolean isValid(IResource parent) throws CoreException;
//
// IWorkspaceRoot getWorkspaceRoot() {
// return ResourcesPlugin.getWorkspace().getRoot();
// }
// }
//
// /**
// * @param testName
// */
// public WorkspaceOperationsTests(String name) {
// super(name);
// }
//
// protected void doSetUp() throws Exception {
// super.doSetUp();
// // Suppress validation UI
// AdvancedValidationUserApprover.AUTOMATED_MODE = true;
// // Project
// testProject = getWorkspace().getRoot().getProject(TEST_PROJECT_NAME);
// testProject.create(getMonitor());
// testProject.open(getMonitor());
// assertTrue(testProject.exists());
// // Project for move/copy target location
// targetProject = getWorkspace().getRoot().getProject(
// TEST_TARGET_PROJECT_NAME);
// targetProject.create(getMonitor());
// targetProject.open(getMonitor());
// assertTrue(targetProject.exists());
// // Folder in Project
// testFolder = testProject.getFolder(TEST_FOLDER_NAME);
// testFolder.create(true, true, getMonitor());
// assertTrue(testFolder.exists());
// // File in Project
// testFileInProject = testProject.getFile(TEST_FILEINPROJECT_NAME);
// testFileInProject.create(getContents(getRandomString()), true,
// getMonitor());
// assertTrue(testFileInProject.exists());
// // Subfolder in top level folder
// testSubFolder = testFolder.getFolder(TEST_SUBFOLDER_NAME);
// testSubFolder.create(true, true, getMonitor());
// assertTrue(testSubFolder.exists());
// // Files in top level folder
// emptyTestFile = testFolder.getFile(TEST_EMPTYFILE_NAME);
// emptyTestFile.create(getContents(FILE_CONTENTS_EMPTY), true,
// getMonitor());
// testFileWithContent = testFolder.getFile(TEST_RANDOMFILE_NAME);
// testFileWithContent.create(getContents(getRandomString()), true,
// getMonitor());
// // File in subfolder
// testFileInSubFolder = testSubFolder.getFile(TEST_FILEINSUBFOLDER_NAME);
// testFileInSubFolder.create(getContents(getRandomString()), true,
// getMonitor());
// assertTrue(testFileInProject.exists());
//
// // Create links by first creating the backing content...
// IFileStore folderStore = getTempStore();
// IFileStore fileStore = getTempStore();
// IPath folderLocation = URIUtil.toPath(folderStore.toURI());
// IPath fileLocation = URIUtil.toPath(fileStore.toURI());
// folderStore.mkdir(EFS.NONE, getMonitor());
// fileStore.openOutputStream(EFS.NONE, getMonitor()).close();
// // Then create the workspace objects
// testLinkedFolder = testFolder.getFolder(TEST_LINKEDFOLDER_NAME);
// testLinkedFolder.createLink(folderLocation, IResource.NONE,
// getMonitor());
// assertTrue(testLinkedFolder.exists());
// testLinkedFile = testFolder.getFile(TEST_LINKEDFILE_NAME);
// testLinkedFile.createLink(fileLocation, IResource.NONE, getMonitor());
//
// history = PlatformUI.getWorkbench().getOperationSupport()
// .getOperationHistory();
// context = PlatformUI.getWorkbench().getOperationSupport()
// .getUndoContext();
//
// }
//
// protected void doTearDown() throws Exception {
// testProject = (IProject) getWorkspaceRoot().findMember(
// TEST_PROJECT_NAME);
// if (testProject != null) {
// testProject.close(getMonitor());
// testProject.delete(true, true, getMonitor());
// }
// targetProject = (IProject) getWorkspaceRoot().findMember(
// TEST_TARGET_PROJECT_NAME);
// if (targetProject != null) {
// targetProject.close(getMonitor());
// targetProject.delete(true, true, getMonitor());
// }
// IProject newProject = (IProject) getWorkspaceRoot().findMember(
// TEST_NEWPROJECT_NAME);
// if (newProject != null) {
// newProject.close(getMonitor());
// newProject.delete(true, true, getMonitor());
// }
// final IFileStore[] toDelete = (IFileStore[]) storesToDelete
// .toArray(new IFileStore[storesToDelete.size()]);
// storesToDelete.clear();
// for (int i = 0; i < toDelete.length; i++) {
// clear(toDelete[i]);
// }
// AdvancedValidationUserApprover.AUTOMATED_MODE = false;
//
// testProject = null;
// targetProject = null;
// testFolder = null;
// testSubFolder = null;
// testLinkedFolder = null;
// emptyTestFile = null;
// testFileWithContent = null;
// testLinkedFile = null;
// testFileInSubFolder = null;
// testFileInProject = null;
//
// super.doTearDown();
// }
//
// private IWorkspace getWorkspace() {
// return ResourcesPlugin.getWorkspace();
// }
//
// private IWorkspaceRoot getWorkspaceRoot() {
// return ResourcesPlugin.getWorkspace().getRoot();
// }
//
// /*
// * reads file content and returns string
// */
// private String readContent(IFile file) throws CoreException {
// InputStream is = file.getContents();
// String encoding = file.getCharset();
// if (is == null)
// return null;
// BufferedReader reader = null;
// try {
// StringBuffer buffer = new StringBuffer();
// char[] part = new char[2048];
// int read = 0;
// reader = new BufferedReader(new InputStreamReader(is, encoding));
//
// while ((read = reader.read(part)) != -1)
// buffer.append(part, 0, read);
//
// return buffer.toString();
//
// } catch (IOException ex) {
// } finally {
// if (reader != null) {
// try {
// reader.close();
// } catch (IOException ex) {
// }
// }
// }
// return null;
// }
//
// private ResourceSnapshot snapshotFromResource(IResource resource)
// throws CoreException {
// if (resource instanceof IFile)
// return new FileSnapshot((IFile) resource);
// if (resource instanceof IFolder)
// return new FolderSnapshot((IFolder) resource);
// if (resource instanceof IProject)
// return new ProjectSnapshot((IProject) resource);
// fail("Unknown resource type");
// // making compiler happy
// return new FileSnapshot((IFile) resource);
// }
//
// private IProgressMonitor getMonitor() {
// return null;
// }
//
// private String getRandomString() {
// switch ((int) Math.round(Math.random() * 10)) {
// case 0:
// return "este e' o meu conteudo (portuguese)";
// case 1:
// return "ho ho ho";
// case 2:
// return "I'll be back";
// case 3:
// return "don't worry, be happy";
// case 4:
// return "there is no imagination for more sentences";
// case 5:
// return "customize yours";
// case 6:
// return "foo";
// case 7:
// return "bar";
// case 8:
// return "foobar";
// case 9:
// return "case 9";
// default:
// return "these are my contents";
// }
// }
//
// /**
// * Returns a FileStore instance backed by storage in a temporary location.
// * The returned store will not exist, but will belong to an existing parent.
// * The tearDown method in this class will ensure the location is deleted
// * after the test is completed.
// */
// private IFileStore getTempStore() {
// IFileStore store = EFS.getLocalFileSystem().getStore(
// FileSystemHelper.getRandomLocation(FileSystemHelper
// .getTempDir()));
// storesToDelete.add(store);
// return store;
// }
//
// /**
// * Returns the URI for a unique, existent folder backed by storage in a
// * temporary location. The tearDown method in this class will ensure the
// * location is deleted after the test is completed.
// */
// private URI getTempProjectDir() throws CoreException {
// IFileStore store = getTempStore();
// store.mkdir(EFS.NONE, getMonitor());
// return store.toURI();
// }
//
// private void clear(IFileStore store) {
// try {
// store.delete(EFS.NONE, null);
// } catch (CoreException e) {
// }
// }
//
// private InputStream getContents(String text) {
// return new ByteArrayInputStream(text.getBytes());
// }
//
// private Map getInitialMarkerAttributes() {
// HashMap map = new HashMap();
// map.putAll(initialAttributes);
// return map;
// }
//
// private Map getUpdatedMarkerAttributes() {
// HashMap map = new HashMap();
// map.putAll(updatedAttributes);
// return map;
// }
//
// private IProjectDescription getNewProjectDescription() {
// return getWorkspace().newProjectDescription(TEST_NEWPROJECT_NAME);
// }
//
// private void execute(AbstractWorkspaceOperation operation)
// throws ExecutionException {
// operation.setQuietCompute(true);
// assertTrue("Operation can be executed", operation.canExecute());
// IStatus status = history.execute(operation, getMonitor(), null);
// assertTrue("Execution should be OK status", status.isOK());
// }
//
// private void executeExpectFail(AbstractWorkspaceOperation operation)
// throws ExecutionException {
// operation.setQuietCompute(true);
// IStatus status = history.execute(operation, getMonitor(), null);
// assertFalse("Execution should not have OK status", status.isOK());
// }
//
// private void undo() throws ExecutionException {
// assertTrue("Operation can be undone", history.canUndo(context));
// IStatus status = history.undo(context, getMonitor(), null);
// assertTrue("Undo should be OK status", status.isOK());
// }
//
// private void undoExpectFail(AbstractWorkspaceOperation operation)
// throws ExecutionException {
// operation.setQuietCompute(true);
// IStatus status = history.undo(context, getMonitor(), null);
// assertFalse("Undo should not have OK status", status.isOK());
// }
//
// private void redo() throws ExecutionException {
// assertTrue("Operation can be redone", history.canRedo(context));
// IStatus status = history.redo(context, getMonitor(), null);
// assertTrue("Redo should be OK status", status.isOK());
// }
//
// private void validateCreatedMarkers(int expectedCount, IMarker[] markers,
// Map[] expectedAttributes, String[] expectedTypes)
// throws CoreException {
//
// assertTrue(MessageFormat.format("{0} markers should have been created",
// new Object[] { new Integer(expectedCount) }),
// markers.length == expectedCount);
//
// for (int i = 0; i < markers.length; i++) {
// IMarker createdMarker = markers[i];
// assertTrue("Marker should exist", createdMarker.exists());
// assertTrue("Marker should have expected attributes", createdMarker
// .getAttributes().equals(expectedAttributes[i]));
// assertTrue("Marker should have expected type", createdMarker
// .getType().equals(expectedTypes[i]));
// }
// }
//
// public void testCreateSingleMarkerUndoRedo() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK };
// Map[] attrs = new Map[] { getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(
// IMarker.BOOKMARK, getInitialMarkerAttributes(), emptyTestFile,
// "Create Single Marker Test");
// execute(op);
// IMarker[] markers = op.getMarkers();
// validateCreatedMarkers(1, markers, attrs, types);
// undo();
// assertFalse("Marker should no longer exist", markers[0].exists());
// redo();
// markers = op.getMarkers();
// validateCreatedMarkers(1, markers, attrs, types);
// }
//
// public void testCreateMultipleMarkersSingleTypeUndoRedo()
// throws ExecutionException, CoreException {
// String[] types = new String[] { CUSTOM_TYPE, CUSTOM_TYPE, CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//
// CreateMarkersOperation op = new CreateMarkersOperation(CUSTOM_TYPE,
// attrs, new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Single Type Test");
// execute(op);
// IMarker[] markers = op.getMarkers();
// validateCreatedMarkers(3, markers, attrs, types);
// undo();
// for (int i = 0; i < markers.length; i++) {
// IMarker createdMarker = markers[i];
// assertFalse("Marker should no longer exist", createdMarker.exists());
// }
// redo();
// markers = op.getMarkers();
// validateCreatedMarkers(3, markers, attrs, types);
// }
//
// public void testCreateMultipleMarkerTypesUndoRedo()
// throws ExecutionException, CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
//
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile }, "Create Multiple Marker Types Test");
// execute(op);
// IMarker[] markers = op.getMarkers();
// validateCreatedMarkers(3, markers, attrs, types);
// undo();
// for (int i = 0; i < markers.length; i++) {
// IMarker createdMarker = markers[i];
// assertFalse("Marker should no longer exist", createdMarker.exists());
// }
// redo();
// markers = op.getMarkers();
// validateCreatedMarkers(3, markers, attrs, types);
// }
//
// public void testUpdateSingleMarkerUndoRedo() throws ExecutionException,
// CoreException {
// CreateMarkersOperation op = new CreateMarkersOperation(
// IMarker.BOOKMARK, getInitialMarkerAttributes(),
// testFileWithContent, "Create Marker Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers()[0], getUpdatedMarkerAttributes(),
// "Update Single Marker", false);
// execute(updateOp);
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { getUpdatedMarkerAttributes() },
// new String[] { IMarker.BOOKMARK });
// undo();
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { getInitialMarkerAttributes() },
// new String[] { IMarker.BOOKMARK });
// redo();
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { getUpdatedMarkerAttributes() },
// new String[] { IMarker.BOOKMARK });
//
// }
//
// public void testUpdateMultipleMarkerUndoRedo() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getInitialMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers(), getUpdatedMarkerAttributes(),
// "Update Multiple Markers", false);
// execute(updateOp);
// validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
// getUpdatedMarkerAttributes(), getUpdatedMarkerAttributes(),
// getUpdatedMarkerAttributes() }, types);
// undo();
// validateCreatedMarkers(3, updateOp.getMarkers(), attrs, types);
// redo();
// validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
// getUpdatedMarkerAttributes(), getUpdatedMarkerAttributes(),
// getUpdatedMarkerAttributes() }, types);
//
// }
//
// public void testUpdateAndMergeSingleMarkerUndoRedo()
// throws ExecutionException, CoreException {
// CreateMarkersOperation op = new CreateMarkersOperation(
// IMarker.BOOKMARK, getInitialMarkerAttributes(), testLinkedFile,
// "Create Marker Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers()[0], getUpdatedMarkerAttributes(),
// "Update And Merge Single Marker", true);
// execute(updateOp);
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { mergedUpdatedAttributes },
// new String[] { IMarker.BOOKMARK });
// undo();
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { getInitialMarkerAttributes() },
// new String[] { IMarker.BOOKMARK });
// redo();
// validateCreatedMarkers(1, updateOp.getMarkers(),
// new Map[] { mergedUpdatedAttributes },
// new String[] { IMarker.BOOKMARK });
//
// }
//
// public void testUpdateAndMergeMultipleMarkerUndoRedo()
// throws ExecutionException, CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getInitialMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers(), getUpdatedMarkerAttributes(),
// "Update and Merge Multiple Markers", true);
// execute(updateOp);
// validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
// mergedUpdatedAttributes, mergedUpdatedAttributes,
// mergedUpdatedAttributes }, types);
// undo();
// validateCreatedMarkers(3, updateOp.getMarkers(), attrs, types);
// redo();
// validateCreatedMarkers(3, updateOp.getMarkers(), new Map[] {
// mergedUpdatedAttributes, mergedUpdatedAttributes,
// mergedUpdatedAttributes }, types);
// }
//
// public void testDeleteMarkersUndoRedo() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// IMarker[] markers = op.getMarkers();
// DeleteMarkersOperation deleteOp = new DeleteMarkersOperation(markers,
// "Delete Markers Test");
// execute(deleteOp);
// for (int i = 0; i < markers.length; i++) {
// IMarker createdMarker = markers[i];
// assertFalse("Marker should no longer exist", createdMarker.exists());
// }
// undo();
// markers = deleteOp.getMarkers();
// validateCreatedMarkers(3, markers, attrs, types);
// redo();
// for (int i = 0; i < markers.length; i++) {
// IMarker createdMarker = markers[i];
// assertFalse("Marker should no longer exist", createdMarker.exists());
// }
// }
//
// /*
// * Test that the undo is invalid because one of the markers was deleted.
// */
// public void testCreateMarkerUndoInvalid() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// IMarker[] markers = op.getMarkers();
// markers[1].delete();
// // Must compute status first because we don't perform expensive
// // validations in canUndo(). However we should remember the validity
// // once we've computed the status.
// op.computeUndoableStatus(null);
// assertFalse("Undo should be invalid, marker no longer exists", op
// .canUndo());
// }
//
// /*
// * Test that the undo is invalid because one of the resources was deleted.
// */
// public void testCreateMarkerUndoInvalid2() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getUpdatedMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// emptyTestFile.delete(true, getMonitor());
// // Must compute status first because we don't perform expensive
// // validations in canUndo(). However we should remember the validity
// // once we've computed the status.
// op.computeUndoableStatus(null);
// assertFalse("Undo should be invalid, resource no longer exists", op
// .canUndo());
// }
//
// public void testUpdateMarkersInvalid() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getInitialMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers(), getUpdatedMarkerAttributes(),
// "Update and Merge Multiple Markers", true);
// execute(updateOp);
// IMarker[] markers = updateOp.getMarkers();
// markers[0].delete();
// // Must compute status first because we don't perform expensive
// // validations in canUndo(). However we should remember the validity
// // once we've computed the status.
// updateOp.computeUndoableStatus(null);
//
// assertFalse("Undo should be invalid, marker no longer exists", updateOp
// .canUndo());
// }
//
// public void testUpdateMarkersInvalid2() throws ExecutionException,
// CoreException {
// String[] types = new String[] { IMarker.BOOKMARK, IMarker.TASK,
// CUSTOM_TYPE };
// Map[] attrs = new Map[] { getInitialMarkerAttributes(),
// getInitialMarkerAttributes(), getInitialMarkerAttributes() };
// CreateMarkersOperation op = new CreateMarkersOperation(types, attrs,
// new IFile[] { emptyTestFile, testFileWithContent,
// testLinkedFile },
// "Create Multiple Markers Same Type Test");
// execute(op);
// UpdateMarkersOperation updateOp = new UpdateMarkersOperation(op
// .getMarkers(), getUpdatedMarkerAttributes(),
// "Update and Merge Multiple Markers", true);
// execute(updateOp);
// testFileWithContent.delete(true, getMonitor());
// // Must compute status first because we don't perform expensive
// // validations in canUndo(). However we should remember the validity
// // once we've computed the status.
// updateOp.computeUndoableStatus(null);
//
// assertFalse("Undo should be invalid, marker no longer exists", updateOp
// .canUndo());
// }
//
// public void testProjectCreateUndoRedo() throws ExecutionException,
// CoreException {
// CreateProjectOperation op = new CreateProjectOperation(
// getNewProjectDescription(), "testProjectCreate");
// execute(op);
// IProject project = getWorkspaceRoot().getProject(TEST_NEWPROJECT_NAME);
// assertTrue("Project creation failed", project.exists());
// ProjectSnapshot snap = new ProjectSnapshot(project);
// undo();
// assertFalse("Project deletion failed", project.exists());
// redo();
// assertTrue("Project recreation failed", project.exists());
// assertTrue("Project not restored properly", snap.isValid());
// }
//
// public void testProjectMoveUndoRedo() throws ExecutionException,
// CoreException {
// URI projectTargetLocation = URIUtil.toURI(URIUtil.toPath(
// getTempProjectDir()).append(TEST_PROJECT_NAME));
// MoveProjectOperation op = new MoveProjectOperation(testProject,
// projectTargetLocation, "testProjectMove");
// ProjectSnapshot snap = new ProjectSnapshot(testProject);
// execute(op);
// assertNotNull("Project move failed", testProject.getDescription()
// .getLocationURI());
// assertTrue("Project contents were altered", snap.isValid());
// undo();
// assertNull("Project move undo failed", testProject.getDescription()
// .getLocationURI());
// assertTrue("Project contents were altered", snap.isValid());
// redo();
// assertEquals("Project move redo failed", testProject.getDescription()
// .getLocationURI(), projectTargetLocation);
// assertTrue("Project contents were altered", snap.isValid());
// }
//
// public void testProjectMoveInvalidLocationUndoRedo()
// throws ExecutionException {
// // invalid target - already used by another project
// MoveProjectOperation op = new MoveProjectOperation(testProject,
// targetProject.getLocationURI(),
// "testProjectMoveInvalidLocation");
// executeExpectFail(op);
// }
//
// public void testProjectCopyUndoRedo() throws ExecutionException,
// CoreException {
// CopyProjectOperation op = new CopyProjectOperation(testProject,
// TEST_NEWPROJECT_NAME, null, "testProjectCopy");
// ProjectSnapshot snap = new ProjectSnapshot(testProject);
// execute(op);
// IProject copiedProject = getWorkspaceRoot().getProject(
// TEST_NEWPROJECT_NAME);
// assertTrue("Project copy failed", copiedProject.exists());
// assertTrue("Source project was altered", snap.isValid());
// snap.name = TEST_NEWPROJECT_NAME;
// assertTrue("Project copy does not match", snap.isValid());
// undo();
// assertFalse("Copy undo failed", copiedProject.exists());
// redo();
// assertTrue("Project not restored properly on redo", snap.isValid());
// snap.name = TEST_PROJECT_NAME;
// assertTrue("Source project was altered", snap.isValid());
// }
//
// public void testProjectClosedCopyUndoRedo() throws ExecutionException,
// CoreException {
// testProject.close(getMonitor());
// testProjectCopyUndoRedo();
// }
//
// public void testProjectCopyAndChangeLocationUndoRedo()
// throws ExecutionException, CoreException {
// URI projectTargetLocation = URIUtil.toURI(URIUtil.toPath(
// getTempProjectDir()).append(TEST_PROJECT_NAME));
// CopyProjectOperation op = new CopyProjectOperation(testProject,
// TEST_NEWPROJECT_NAME, projectTargetLocation,
// "testProjectCopyToNewLocation");
// ProjectSnapshot snap = new ProjectSnapshot(testProject);
// execute(op);
// IProject copiedProject = getWorkspaceRoot().getProject(
// TEST_NEWPROJECT_NAME);
// assertTrue("Project copy failed", copiedProject.exists());
// assertEquals("Project location copy failed", copiedProject
// .getDescription().getLocationURI(), projectTargetLocation);
// assertTrue("Source project was altered", snap.isValid());
// snap.name = TEST_NEWPROJECT_NAME;
// assertTrue("Project copy does not match", snap.isValid());
// undo();
// assertFalse("Copy undo failed", copiedProject.exists());
// redo();
// assertTrue("Project not restored properly on redo", snap.isValid());
// assertEquals("Project location not restored properly", copiedProject
// .getDescription().getLocationURI(), projectTargetLocation);
// snap.name = TEST_PROJECT_NAME;
// assertTrue("Source project was altered", snap.isValid());
// }
//
// public void testProjectClosedCopyAndChangeLocationUndoRedo()
// throws ExecutionException, CoreException {
// testProject.close(getMonitor());
// testProjectCopyAndChangeLocationUndoRedo();
// }
//
// public void testProjectCopyAndChangeToInvalidLocationUndoRedo()
// throws ExecutionException {
// // invalid target - already used by another project
// CopyProjectOperation op = new CopyProjectOperation(testProject,
// TEST_NEWPROJECT_NAME, targetProject.getLocationURI(),
// "testProjectCopyInvalidLocation");
// executeExpectFail(op);
// }
//
// public void testProjectRenameUndoRedo() throws ExecutionException,
// CoreException {
// MoveResourcesOperation op = new MoveResourcesOperation(testProject,
// new Path(TEST_NEWPROJECT_NAME), "testProjectRename");
// ProjectSnapshot snap = new ProjectSnapshot(testProject);
// execute(op);
// IProject renamedProject = getWorkspaceRoot().getProject(
// TEST_NEWPROJECT_NAME);
// assertTrue("Project rename failed", renamedProject.exists());
// snap.name = TEST_NEWPROJECT_NAME;
// assertTrue("Project content was altered on rename", snap.isValid());
// undo();
// snap.name = TEST_PROJECT_NAME;
// assertTrue("Project content was altered on undo rename", snap.isValid());
// assertFalse("Undo rename failed", renamedProject.exists());
// redo();
// snap.name = TEST_NEWPROJECT_NAME;
// assertTrue("Project content was altered on redo rename", snap.isValid());
// }
//
// public void testProjectDeleteUndoRedo() throws ExecutionException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testProject }, "testProjectDelete", false);
// execute(op);
// assertFalse("Project delete failed", testProject.exists());
// undo();
// assertTrue("Project recreation failed", testProject.exists());
// // Ideally we could run this test everytime, but it fails intermittently
// // because opening the recreated project occurs in the background, and
// // the creation of the workspace representation for the disk contents
// // may not have happened yet. This test always passes under debug where
// // timing can be controlled.
// // ***********
// // assertTrue("Project content was altered on undo", snap.isValid());
// // ************
// redo();
// assertFalse("Redo delete failed", testProject.exists());
// // We undo again so that the project will exist during teardown and
// // get cleaned up. Otherwise some content is left on disk.
// undo();
// }
//
// public void testProjectClosedDeleteUndoRedo() throws ExecutionException,
// CoreException {
// testProject.close(getMonitor());
// testProjectDeleteUndoRedo();
// }
//
// public void testProjectDeleteWithContentUndoRedo()
// throws ExecutionException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testProject }, "testProjectDelete", true);
// // we don't snapshot since content will be deleted
// execute(op);
// assertFalse("Project delete failed", testProject.exists());
// undo();
// assertTrue("Project was recreated", testProject.exists());
// redo();
// assertFalse("Redo delete failed", testProject.exists());
// }
//
// public void testProjectClosedDeleteWithContentUndoRedo()
// throws ExecutionException, CoreException {
// testProject.close(getMonitor());
// testProjectDeleteWithContentUndoRedo();
// }
//
// public void testFolderCreateLeafUndoRedo() throws ExecutionException {
// IFolder folder = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(TEST_NEWFOLDER_NAME));
// CreateFolderOperation op = new CreateFolderOperation(folder, null,
// "testFolderCreateLeaf");
// assertFalse("Folder should not exist before test is run", folder
// .exists());
// execute(op);
// assertTrue("Folder creation failed", folder.exists());
// undo();
// assertFalse("Folder deletion failed", folder.exists());
// redo();
// assertTrue("Folder recreation failed", folder.exists());
// }
//
// public void testFolderCreateNestedInProjectUndoRedo()
// throws ExecutionException {
// // uses a nested path to force creation of nonexistent parents
// IFolder folder = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
// CreateFolderOperation op = new CreateFolderOperation(folder, null,
// "testFolderCreateNested");
// assertFalse("Folder should not exist before test is run", folder
// .exists());
// execute(op);
// assertTrue("Folder creation failed", folder.exists());
// undo();
// assertFalse("Folder deletion failed", folder.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(path));
// assertFalse("Deletion of created parents failed", parent.exists());
//
// redo();
// assertTrue("Folder recreation failed", folder.exists());
// }
//
// public void testFolderCreateNestedInFolderUndoRedo()
// throws ExecutionException {
// // Uses a nested path to force creation of nonexistent parents.
// // Parent is a folder, not a project.
// IFolder folder = getWorkspaceRoot().getFolder(
// testFolder.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
// CreateFolderOperation op = new CreateFolderOperation(folder, null,
// "testFolderCreateNestedInFolder");
// assertFalse("Folder should not exist before test is run", folder
// .exists());
// execute(op);
// assertTrue("Folder creation failed", folder.exists());
//
// undo();
// assertFalse("Folder deletion failed", folder.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testFolder.getFullPath().append(path));
// assertFalse("Deletion of created parents failed", parent.exists());
//
// redo();
// assertTrue("Folder recreation failed", folder.exists());
// }
//
// public void testFolderCreateLinkedUndoRedo() throws ExecutionException {
// IFolder folder = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(TEST_NEWFOLDER_NAME));
// CreateFolderOperation op = new CreateFolderOperation(folder,
// testSubFolder.getLocationURI(), "testFolderCreateLink");
// assertFalse("Folder should not exist before test is run", folder
// .exists());
// execute(op);
// assertTrue("Folder creation failed", folder.exists());
// assertTrue("Folder was not created as a link", folder.isLinked());
// undo();
// assertFalse("Folder deletion failed", folder.exists());
// redo();
// assertTrue("Folder recreation failed", folder.exists());
// assertTrue("Folder was not recreated as a link", folder.isLinked());
// }
//
// public void testFolderCreateLinkedNestedUndoRedo()
// throws ExecutionException {
// // Use nested name with uncreated parents
// IFolder folder = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(TEST_NEWNESTEDFOLDER_NAME));
// CreateFolderOperation op = new CreateFolderOperation(folder,
// testSubFolder.getLocationURI(), "testFolderCreateNestedLink");
// assertFalse("Folder should not exist before test is run", folder
// .exists());
// execute(op);
// assertTrue("Folder creation failed", folder.exists());
// assertTrue("Folder was not created as a link", folder.isLinked());
// undo();
// assertFalse("Folder deletion failed", folder.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFOLDER_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(path));
// assertFalse("Parents should have been removed", parent.exists());
// // Redo
// redo();
// assertTrue("Folder recreation failed", folder.exists());
// assertTrue("Folder was not recreated as a link", folder.isLinked());
// }
//
// public void testFolderMoveUndoRedo() throws ExecutionException,
// CoreException {
// IPath targetPath = targetProject.getFullPath().append(
// testFolder.getName());
// MoveResourcesOperation op = new MoveResourcesOperation(testFolder,
// targetPath, "testFolderMove");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// IFolder movedFolder = getWorkspaceRoot().getFolder(targetPath);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
//
// undo();
// movedFolder = getWorkspaceRoot().getFolder(targetPath);
// assertFalse("Move undo failed", movedFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testProject));
//
// redo();
// movedFolder = getWorkspaceRoot().getFolder(targetPath);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
// }
//
// public void testRedundantSubFolderMoveUndoRedo() throws ExecutionException,
// CoreException {
// IPath targetPath = targetProject.getFullPath();
// IPath targetPathWithName = targetPath.append(testFolder.getName());
// MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
// testFolder, testSubFolder }, targetPath,
// "testRedundantSubFolderMove");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// IFolder movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
//
// undo();
// movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertFalse("Move undo failed", movedFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testProject));
//
// redo();
// movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
// }
//
// public void testRedundantFolderFileMoveUndoRedo()
// throws ExecutionException, CoreException {
// IPath targetPath = targetProject.getFullPath();
// IPath targetPathWithName = targetPath.append(testFolder.getName());
// MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
// testFolder, testFileWithContent }, targetPath,
// "testRedundantFolderFileMove");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// IFolder movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
//
// undo();
// movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertFalse("Move undo failed", movedFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testProject));
//
// redo();
// movedFolder = getWorkspaceRoot().getFolder(targetPathWithName);
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snap.isValid(targetProject));
// }
//
// public void testFolderCopyUndoRedo() throws ExecutionException,
// CoreException {
// // copying with same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(
// new IResource[] { testFolder }, targetProject.getFullPath(),
// "testFolderCopy");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// IFolder copiedFolder = targetProject.getFolder(testFolder.getName());
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snap.isValid(testProject));
// assertTrue("Folder copy does not match", snap.isValid(targetProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFolder.exists());
//
// redo();
// assertTrue("Folder not restored properly on redo", snap
// .isValid(targetProject));
// assertTrue("Source folder was altered", snap.isValid(testProject));
// }
//
// public void testFolderCopyLinkUndoRedo() throws ExecutionException,
// CoreException {
// // copying with same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(
// new IResource[] { testLinkedFolder }, targetProject
// .getFullPath(), "testLinkedFolderCopy");
// FolderSnapshot snap = new FolderSnapshot(testLinkedFolder);
// execute(op);
// IFolder copiedFolder = targetProject.getFolder(testLinkedFolder
// .getName());
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snap.isValid(testFolder));
// assertTrue("Folder copy does not match", snap.isValid(targetProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFolder.exists());
//
// redo();
// assertTrue("Folder not restored properly on redo", snap
// .isValid(targetProject));
// assertTrue("Source folder was altered", snap.isValid(testFolder));
// }
//
// public void testFolderCopyRenameUndoRedo() throws ExecutionException,
// CoreException {
// // copying with a different name to the same project
// CopyResourcesOperation op = new CopyResourcesOperation(testFolder,
// testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
// "testFolderCopyRename");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
//
// IFolder copiedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snap.isValid(testProject));
// snap.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder copy does not match", snap.isValid(testProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFolder.exists());
//
// redo();
// assertTrue("Folder not restored properly on redo", snap
// .isValid(testProject));
// snap.name = TEST_FOLDER_NAME;
// assertTrue("Source folder was altered", snap.isValid(testProject));
//
// }
//
// public void testFolderRenameUndoRedo() throws ExecutionException,
// CoreException {
// MoveResourcesOperation op = new MoveResourcesOperation(testFolder,
// testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
// "testFolderRename");
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// IFolder renamedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
// assertTrue("Project rename failed", renamedFolder.exists());
// snap.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder content was altered on rename", snap
// .isValid(testProject));
//
// undo();
// snap.name = TEST_FOLDER_NAME;
// assertTrue("Folder content was altered on undo rename", snap
// .isValid(testProject));
// assertFalse("Undo rename failed", renamedFolder.exists());
//
// redo();
// snap.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder content was altered on redo rename", snap
// .isValid(testProject));
// }
//
// public void testFolderDeleteUndoRedo() throws ExecutionException,
// CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testSubFolder }, "testFolderDelete", false);
// FolderSnapshot snap = new FolderSnapshot(testSubFolder);
// execute(op);
// assertFalse("Folder delete failed", testSubFolder.exists());
// undo();
// assertTrue("Folder recreation failed", testSubFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testSubFolder.getParent()));
// redo();
// assertFalse("Redo delete failed", testSubFolder.exists());
// }
//
// public void testNestedRedundantFolderDeleteUndoRedo()
// throws ExecutionException, CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testFolder, testSubFolder },
// "testNestedRedundantFolderDelete", false);
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// assertFalse("Folder delete failed", testFolder.exists());
// undo();
// assertTrue("Folder recreation failed", testFolder.exists());
// assertTrue("SubFolder recreation failed", testSubFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testFolder.getParent()));
// redo();
// assertFalse("Redo delete failed", testFolder.exists());
// }
//
// public void testNestedRedundantFileDeleteUndoRedo()
// throws ExecutionException, CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testFolder, testFileWithContent },
// "testNestedRedundantFileDelete", false);
// FolderSnapshot snap = new FolderSnapshot(testFolder);
// execute(op);
// assertFalse("Folder delete failed", testFolder.exists());
// undo();
// assertTrue("Folder recreation failed", testFolder.exists());
// assertTrue("SubFolder recreation failed", testSubFolder.exists());
// assertTrue("File recreation failed", testFileWithContent.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testFolder.getParent()));
// redo();
// assertFalse("Redo delete failed", testFolder.exists());
// }
//
// public void testFolderDeleteLinkedUndoRedo() throws ExecutionException,
// CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testLinkedFolder }, "testFolderDeleteLinked",
// false);
// FolderSnapshot snap = new FolderSnapshot(testLinkedFolder);
// execute(op);
// assertFalse("Folder delete failed", testLinkedFolder.exists());
// undo();
// assertTrue("Folder recreation failed", testLinkedFolder.exists());
// assertTrue("Folder content was altered on undo", snap
// .isValid(testLinkedFolder.getParent()));
// redo();
// assertFalse("Redo delete failed", testLinkedFolder.exists());
// }
//
// public void testFileCreateLeafUndoRedo() throws ExecutionException,
// CoreException {
// IFile file = getWorkspaceRoot().getFile(
// testProject.getFullPath().append(TEST_NEWFILE_NAME));
// CreateFileOperation op = new CreateFileOperation(file, null,
// getContents(getRandomString()), "testFileCreateLeaf");
// assertFalse("File should not exist before test is run", file.exists());
// execute(op);
// assertTrue("File creation failed", file.exists());
// FileSnapshot snapshot = new FileSnapshot(file);
// undo();
// assertFalse("File deletion failed", file.exists());
// redo();
// assertTrue("File recreation failed", file.exists());
// assertTrue("File content improperly restored", snapshot.isValid(file
// .getParent()));
// }
//
// public void testFileCreateNestedInProjectUndoRedo()
// throws ExecutionException, CoreException {
// // Uses file name with non-existent folder parents
// IFile file = getWorkspaceRoot().getFile(
// testProject.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
// CreateFileOperation op = new CreateFileOperation(file, null,
// getContents(getRandomString()), "testFileCreateNestedInProject");
// assertFalse("File should not exist before test is run", file.exists());
// execute(op);
// assertTrue("File creation failed", file.exists());
// FileSnapshot snapshot = new FileSnapshot(file);
//
// undo();
// assertFalse("File deletion failed", file.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(path));
// assertFalse("Deletion of created parents failed", parent.exists());
//
// redo();
// assertTrue("File recreation failed", file.exists());
// assertTrue("File content improperly restored", snapshot.isValid(file
// .getParent()));
// }
//
// public void testFileCreateNestedInFolderUndoRedo()
// throws ExecutionException, CoreException {
// // Uses file name with non-existent folder parents.
// // Uses subfolder as a parent
// IFile file = getWorkspaceRoot().getFile(
// testSubFolder.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
// CreateFileOperation op = new CreateFileOperation(file, null,
// getContents(getRandomString()),
// "testFileCreateNestedInSubfolder");
// assertFalse("File should not exist before test is run", file.exists());
// execute(op);
// assertTrue("File creation failed", file.exists());
// FileSnapshot snapshot = new FileSnapshot(file);
//
// undo();
// assertFalse("File deletion failed", file.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testSubFolder.getFullPath().append(path));
// assertFalse("Deletion of created parents failed", parent.exists());
//
// redo();
// assertTrue("File recreation failed", file.exists());
// assertTrue("File content improperly restored", snapshot.isValid(file
// .getParent()));
// }
//
// public void testFileCreateLinkedUndoRedo() throws ExecutionException,
// CoreException {
// IFile file = getWorkspaceRoot().getFile(
// testProject.getFullPath().append(TEST_NEWFILE_NAME));
// CreateFileOperation op = new CreateFileOperation(file,
// testFileWithContent.getLocationURI(), null,
// "testFileCreateLink");
// assertFalse("File should not exist before test is run", file.exists());
//
// execute(op);
// assertTrue("File creation failed", file.exists());
// assertTrue("File was not created as link", file.isLinked());
// assertEquals("Linked content not equal", readContent(file),
// readContent(testFileWithContent));
//
// undo();
// assertFalse("File deletion failed", file.exists());
//
// redo();
// assertTrue("File was not created as link", file.isLinked());
// assertEquals("Linked content not equal", readContent(file),
// readContent(testFileWithContent));
// }
//
// public void testFileCreateLinkedNestedUndoRedo() throws ExecutionException,
// CoreException {
// IFile file = getWorkspaceRoot().getFile(
// testProject.getFullPath().append(TEST_NEWNESTEDFILE_NAME));
// CreateFileOperation op = new CreateFileOperation(file,
// testFileWithContent.getLocationURI(), null,
// "testFileCreateLinkNested");
// assertFalse("File should not exist before test is run", file.exists());
//
// execute(op);
// assertTrue("File creation failed", file.exists());
// assertTrue("File was not created as link", file.isLinked());
// assertEquals("Linked content not equal", readContent(file),
// readContent(testFileWithContent));
//
// undo();
// assertFalse("File deletion failed", file.exists());
// // Ensure all created parents are gone, too
// IPath path = new Path(TEST_NEWNESTEDFILE_NAME);
// path.removeLastSegments(path.segmentCount() - 1);
// IFolder parent = getWorkspaceRoot().getFolder(
// testProject.getFullPath().append(path));
// assertFalse("Deletion of created parents failed", parent.exists());
//
// redo();
// assertTrue("File was not created as link", file.isLinked());
// assertEquals("Linked content not equal", readContent(file),
// readContent(testFileWithContent));
// }
//
// public void testFileMoveUndoRedo() throws ExecutionException, CoreException {
// // Moving from a folder in one project to the top level of another
// // project
// IPath targetPath = targetProject.getFullPath().append(
// testFileWithContent.getName());
// MoveResourcesOperation op = new MoveResourcesOperation(
// testFileWithContent, targetPath, "testFileMove");
// FileSnapshot snap = new FileSnapshot(testFileWithContent);
// execute(op);
// IFile movedFile = getWorkspaceRoot().getFile(targetPath);
// assertTrue("File move failed", movedFile.exists());
// assertTrue("File content was altered", snap.isValid(targetProject));
//
// undo();
// movedFile = getWorkspaceRoot().getFile(targetPath);
// assertFalse("Move undo failed", movedFile.exists());
// assertTrue("File content was altered on undo", snap.isValid(testFolder));
//
// redo();
// movedFile = getWorkspaceRoot().getFile(targetPath);
// assertTrue("File move failed", movedFile.exists());
// assertTrue("File content was altered", snap.isValid(targetProject));
// }
//
// public void testFileMoveAndOverwriteUndoRedo() throws ExecutionException,
// CoreException {
// // Moving a file from a folder inside that the same folder on top of an
// // existent file
// IPath sourcePath = emptyTestFile.getFullPath();
// IPath targetPath = testFileWithContent.getFullPath();
// MoveResourcesOperation op = new MoveResourcesOperation(emptyTestFile,
// targetPath, "testFileMoveOverwrite");
// FileSnapshot source = new FileSnapshot(emptyTestFile);
// FileSnapshot overwritten = new FileSnapshot(testFileWithContent);
// execute(op);
// IFile sourceFile = getWorkspaceRoot().getFile(sourcePath);
// assertFalse("File move failed", sourceFile.exists());
// source.name = TEST_RANDOMFILE_NAME;
// assertTrue("Source content was altered at target", source
// .isValid(testFolder));
//
// undo();
// assertTrue("File restore failed", sourceFile.exists());
// assertTrue("Overwritten file was not restored", overwritten
// .isValid(testFolder));
// source.name = TEST_EMPTYFILE_NAME;
// assertTrue("Source file content was not restored", source
// .isValid(testFolder));
//
// redo();
// sourceFile = getWorkspaceRoot().getFile(sourcePath);
// assertFalse("File move failed", sourceFile.exists());
// source.name = TEST_RANDOMFILE_NAME;
// assertTrue("Source content was altered at target", source
// .isValid(testFolder));
// }
//
// public void testFileCopyUndoRedo() throws ExecutionException, CoreException {
// // copying with same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(
// new IResource[] { testFileWithContent }, targetProject
// .getFullPath(), "testFileCopy");
// FileSnapshot snap = new FileSnapshot(testFileWithContent);
// execute(op);
// IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source file was altered", snap.isValid(testFolder));
// assertTrue("File copy does not match", snap.isValid(targetProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFile.exists());
//
// redo();
// assertTrue("File not restored properly on redo", snap
// .isValid(targetProject));
// assertTrue("Source file was altered", snap.isValid(testFolder));
// }
//
// public void testFileCopyLinkUndoRedo() throws ExecutionException,
// CoreException {
// // copying with same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(
// new IResource[] { testLinkedFile },
// targetProject.getFullPath(), "testFileLinkCopy");
// FileSnapshot snap = new FileSnapshot(testLinkedFile);
// execute(op);
// IFile copiedFile = targetProject.getFile(testLinkedFile.getName());
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source file was altered", snap.isValid(testFolder));
// assertTrue("File copy does not match", snap.isValid(targetProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFile.exists());
//
// redo();
// assertTrue("File not restored properly on redo", snap
// .isValid(targetProject));
// assertTrue("Source file was altered", snap.isValid(testFolder));
// }
//
// public void testFileCopyRenameUndoRedo() throws ExecutionException,
// CoreException {
// // copying with a different name to the same project
// CopyResourcesOperation op = new CopyResourcesOperation(
// testFileWithContent, testProject.getFullPath().append(
// TEST_NEWFILE_NAME), "testFileCopyRename");
// FileSnapshot snap = new FileSnapshot(testFileWithContent);
// execute(op);
//
// IFile copiedFile = testProject.getFile(TEST_NEWFILE_NAME);
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source folder was altered", snap.isValid(testFolder));
// snap.name = TEST_NEWFILE_NAME;
// assertTrue("File copy does not match", snap.isValid(testProject));
//
// undo();
// assertFalse("Copy undo failed", copiedFile.exists());
//
// redo();
// assertTrue("File not restored properly on redo", snap
// .isValid(testProject));
// snap.name = TEST_RANDOMFILE_NAME;
// assertTrue("Source folder was altered", snap.isValid(testFolder));
// }
//
// public void testFileCopyAndOverwriteUndoRedo() throws ExecutionException,
// CoreException {
// // Copying from a file in a folder to the same folder on top of an
// // existent file
// IPath targetPath = testFileWithContent.getFullPath();
// CopyResourcesOperation op = new CopyResourcesOperation(emptyTestFile,
// targetPath, "testFileMoveOverwrite");
// FileSnapshot source = new FileSnapshot(emptyTestFile);
// FileSnapshot overwritten = new FileSnapshot(testFileWithContent);
// execute(op);
// assertTrue("Source content was altered", source.isValid(testFolder));
// source.name = TEST_RANDOMFILE_NAME;
// assertTrue("Source content was altered at target", source
// .isValid(testFolder));
//
// undo();
// assertTrue("Overwritten file was not restored", overwritten
// .isValid(testFolder));
// source.name = TEST_EMPTYFILE_NAME;
// assertTrue("Source file content was not restored", source
// .isValid(testFolder));
//
// redo();
// source.name = TEST_RANDOMFILE_NAME;
// assertTrue("Source content was altered at target", source
// .isValid(testFolder));
// }
//
// public void testFileRenameUndoRedo() throws ExecutionException,
// CoreException {
// MoveResourcesOperation op = new MoveResourcesOperation(
// testFileInProject, testProject.getFullPath().append(
// TEST_NEWFILE_NAME), "testFileRename");
// FileSnapshot snap = new FileSnapshot(testFileInProject);
// execute(op);
// IFile renamedFile = testProject.getFile(TEST_NEWFILE_NAME);
// assertTrue("File rename failed", renamedFile.exists());
// snap.name = TEST_NEWFILE_NAME;
// assertTrue("File content was altered on rename", snap
// .isValid(testProject));
//
// undo();
// snap.name = TEST_FILEINPROJECT_NAME;
// assertTrue("File content was altered on undo rename", snap
// .isValid(testProject));
// assertFalse("Undo rename failed", renamedFile.exists());
//
// redo();
// snap.name = TEST_NEWFILE_NAME;
// assertTrue("File content was altered on redo rename", snap
// .isValid(testProject));
// }
//
// public void testFileDeleteUndoRedo() throws ExecutionException,
// CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testFileWithContent }, "testFileDelete",
// false);
// FileSnapshot snap = new FileSnapshot(testFileWithContent);
// execute(op);
// assertFalse("File delete failed", testFileWithContent.exists());
// undo();
// assertTrue("File recreation failed", testFileWithContent.exists());
// assertTrue("File content was altered on undo", snap
// .isValid(testFileWithContent.getParent()));
// redo();
// assertFalse("Redo delete failed", testFileWithContent.exists());
// }
//
// public void testFileLinkedDeleteUndoRedo() throws ExecutionException,
// CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testLinkedFile }, "testLinkedFileDelete",
// false);
// FileSnapshot snap = new FileSnapshot(testLinkedFile);
// execute(op);
// assertFalse("File delete failed", testLinkedFile.exists());
// undo();
// assertTrue("File recreation failed", testLinkedFile.exists());
// assertTrue("File content was altered on undo", snap
// .isValid(testLinkedFile.getParent()));
// redo();
// assertFalse("Redo delete failed", testLinkedFile.exists());
// }
//
// public void testFileAndFolderMoveSameDests() throws ExecutionException,
// CoreException {
// IPath targetPath = targetProject.getFullPath();
// MoveResourcesOperation op = new MoveResourcesOperation(new IResource[] {
// testSubFolder, testFileWithContent }, targetPath,
// "testFileAndFolderMove");
// FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
// FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
// execute(op);
// IFolder movedFolder = getWorkspaceRoot().getFolder(
// targetPath.append(TEST_SUBFOLDER_NAME));
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snapFolder
// .isValid(targetProject));
// IFile movedFile = getWorkspaceRoot().getFile(
// targetPath.append(TEST_RANDOMFILE_NAME));
// assertTrue("File move failed", movedFile.exists());
// assertTrue("File content was altered", snapFile.isValid(targetProject));
//
// undo();
// movedFolder = getWorkspaceRoot().getFolder(
// targetPath.append(TEST_SUBFOLDER_NAME));
// assertFalse("Move undo failed", movedFolder.exists());
// assertTrue("Folder content was altered on undo", snapFolder
// .isValid(testFolder));
// movedFile = getWorkspaceRoot().getFile(
// targetPath.append(TEST_RANDOMFILE_NAME));
// assertFalse("Move undo failed", movedFolder.exists());
// assertTrue("File content was altered on undo", snapFile
// .isValid(testFolder));
//
// redo();
// movedFolder = getWorkspaceRoot().getFolder(
// targetPath.append(TEST_SUBFOLDER_NAME));
// assertTrue("Folder move failed", movedFolder.exists());
// assertTrue("Folder content was altered", snapFolder
// .isValid(targetProject));
// movedFile = getWorkspaceRoot().getFile(
// targetPath.append(TEST_RANDOMFILE_NAME));
// assertTrue("File move failed", movedFile.exists());
// assertTrue("File content was altered", snapFile.isValid(targetProject));
// }
//
// public void testFileAndFolderCopyDifferentDests()
// throws ExecutionException, CoreException {
// // copying a file and folder to different destination projects,
// // assigning new names to a new project
// // The folder gets a new name, the file retains the old name
// CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
// testSubFolder, testFileWithContent }, new IPath[] {
// testProject.getFullPath().append(TEST_NEWFOLDER_NAME),
// targetProject.getFullPath().append(
// testFileWithContent.getName()) },
// "testFileAndFolderDifferentDests");
// FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
// FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
// execute(op);
// IFolder copiedFolder = testProject.getFolder(TEST_NEWFOLDER_NAME);
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
// snapFolder.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder copy does not match", snapFolder
// .isValid(testProject));
// IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source file was altered", snapFile.isValid(testFolder));
// assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
// undo();
// assertFalse("Copy folder undo failed", copiedFolder.exists());
// assertFalse("Copy file undo failed", copiedFile.exists());
// snapFolder.name = testSubFolder.getName();
// assertTrue("Source file was altered during undo", snapFile
// .isValid(testFolder));
// assertTrue("Source folder was altered during undo", snapFolder
// .isValid(testFolder));
//
// redo();
// assertTrue("Source folder was altered during redo", snapFolder
// .isValid(testFolder));
// snapFolder.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder copy does not match on redo", snapFolder
// .isValid(testProject));
// assertTrue("Source file was altered during redo", snapFile
// .isValid(testFolder));
// assertTrue("File copy does not match on redo", snapFile
// .isValid(targetProject));
// }
//
// public void testFileAndFolderCopyDifferentNames()
// throws ExecutionException, CoreException {
// // copying a file and folder to a new project, assigning new names to a
// // new project
// CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
// testSubFolder, testFileWithContent }, new IPath[] {
// targetProject.getFullPath().append(TEST_NEWFOLDER_NAME),
// targetProject.getFullPath().append(TEST_NEWFILE_NAME) },
// "testFileAndFolderDifferentNames");
// FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
// FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
// execute(op);
// IFolder copiedFolder = targetProject.getFolder(TEST_NEWFOLDER_NAME);
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
// snapFolder.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder copy does not match", snapFolder
// .isValid(targetProject));
// IFile copiedFile = targetProject.getFile(TEST_NEWFILE_NAME);
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source file was altered", snapFile.isValid(testFolder));
// snapFile.name = TEST_NEWFILE_NAME;
// assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
// undo();
// assertFalse("Copy folder undo failed", copiedFolder.exists());
// assertFalse("Copy file undo failed", copiedFile.exists());
// snapFolder.name = testSubFolder.getName();
// assertTrue("Source file was altered during undo", snapFolder
// .isValid(testFolder));
// snapFile.name = testFileWithContent.getName();
// assertTrue("Source folder was altered during undo", snapFile
// .isValid(testFolder));
//
// redo();
// assertTrue("Source folder was altered during redo", snapFolder
// .isValid(testFolder));
// snapFolder.name = TEST_NEWFOLDER_NAME;
// assertTrue("Folder copy does not match on redo", snapFolder
// .isValid(targetProject));
// assertTrue("Source file was altered during redo", snapFile
// .isValid(testFolder));
// snapFile.name = TEST_NEWFILE_NAME;
// assertTrue("File copy does not match on redo", snapFile
// .isValid(targetProject));
// }
//
// public void testRedundantFileAndFolderCopy() throws CoreException,
// ExecutionException {
// // copying a file which is a child of a folder, keeping same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
// testFolder, testFileWithContent }, targetProject
// .getFullPath(), "testRedundantFileAndFolderCopy");
// FolderSnapshot snapFolder = new FolderSnapshot(testFolder);
// FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
// execute(op);
// IFolder copiedFolder = targetProject.getFolder(testFolder.getName());
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snapFolder.isValid(testProject));
// assertTrue("Folder copy does not match", snapFolder
// .isValid(targetProject));
// IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
// assertFalse("Nested file should not have been copied to new location", copiedFile.exists());
// copiedFile = testFolder.getFile(testFileWithContent.getName());
// assertTrue("Nested file should have been copied to existing parent", copiedFile.exists());
// assertTrue("Source file was altered", snapFile.isValid(testFolder));
//
// undo();
// assertFalse("Copy folder undo failed", copiedFolder.exists());
// assertTrue("Source file was altered during undo", snapFile
// .isValid(testFolder));
// assertTrue("Source folder was altered during undo", snapFolder
// .isValid(testProject));
//
// redo();
// assertTrue("Source folder was altered during redo", snapFolder
// .isValid(testProject));
// assertTrue("Folder copy does not match on redo", snapFolder
// .isValid(targetProject));
// assertTrue("Source file was altered during redo", snapFile
// .isValid(testFolder));
// }
//
// public void testFileAndFolderCopySameDests() throws ExecutionException,
// CoreException {
// // copying a file and folder, keeping same name to a new project
// CopyResourcesOperation op = new CopyResourcesOperation(new IResource[] {
// testSubFolder, testFileWithContent }, targetProject
// .getFullPath(), "testFileAndFolderCopy");
// FolderSnapshot snapFolder = new FolderSnapshot(testSubFolder);
// FileSnapshot snapFile = new FileSnapshot(testFileWithContent);
// execute(op);
// IFolder copiedFolder = targetProject.getFolder(testSubFolder.getName());
// assertTrue("Folder copy failed", copiedFolder.exists());
// assertTrue("Source folder was altered", snapFolder.isValid(testFolder));
// assertTrue("Folder copy does not match", snapFolder
// .isValid(targetProject));
// IFile copiedFile = targetProject.getFile(testFileWithContent.getName());
// assertTrue("File copy failed", copiedFile.exists());
// assertTrue("Source file was altered", snapFile.isValid(testFolder));
// assertTrue("File copy does not match", snapFile.isValid(targetProject));
//
// undo();
// assertFalse("Copy folder undo failed", copiedFolder.exists());
// assertFalse("Copy file undo failed", copiedFile.exists());
// assertTrue("Source file was altered during undo", snapFile
// .isValid(testFolder));
// assertTrue("Source folder was altered during undo", snapFolder
// .isValid(testFolder));
//
// redo();
// assertTrue("Source folder was altered during redo", snapFolder
// .isValid(testFolder));
// assertTrue("Folder copy does not match on redo", snapFolder
// .isValid(targetProject));
// assertTrue("Source file was altered during redo", snapFile
// .isValid(testFolder));
// assertTrue("File copy does not match on redo", snapFile
// .isValid(targetProject));
// }
//
// public void testWorkspaceUndoMonitor() throws ExecutionException,
// CoreException {
// // First we copy the project to the target location
// // This gives us lots of stuff to delete in order to manufacture some
// // workspace changes
// CopyProjectOperation op = new CopyProjectOperation(testProject,
// TEST_NEWPROJECT_NAME, null, "testProjectCopy");
// execute(op);
// // Now we are going to create a new file
// IFile file = getWorkspaceRoot().getFile(
// testProject.getFullPath().append(TEST_NEWFILE_NAME));
// CreateFileOperation op2 = new CreateFileOperation(file, null,
// getContents(getRandomString()), "testFileCreateLeaf");
// execute(op2);
// assertTrue("Operation should be valid", op2.canUndo());
// int changes = 0;
// // back door delete the new file
// file.delete(true, getMonitor());
// changes++;
// // op still doesn't know it's invalid because undo monitor hasn't
// // had changes to force checking it.
// assertTrue("Operation should be valid", op2.canUndo());
//
// // Now perform a bunch of changes
// emptyTestFile.delete(true, getMonitor());
// changes++;
// testFileInProject.delete(true, getMonitor());
// changes++;
// testFileInSubFolder.delete(true, getMonitor());
// changes++;
// testFileWithContent.delete(true, getMonitor());
// changes++;
// testLinkedFile.delete(true, getMonitor());
// changes++;
// testLinkedFolder.delete(true, getMonitor());
// changes++;
// testSubFolder.delete(true, getMonitor());
// changes++;
// testFolder.delete(true, getMonitor());
// changes++;
// testFolder = testProject.getFolder(TEST_FOLDER_NAME);
// testFolder.create(true, true, getMonitor());
// changes++;
// testFileInProject = testProject.getFile(TEST_FILEINPROJECT_NAME);
// testFileInProject.create(getContents(getRandomString()), true,
// getMonitor());
// changes++;
// testSubFolder = testFolder.getFolder(TEST_SUBFOLDER_NAME);
// testSubFolder.create(true, true, getMonitor());
// changes++;
// emptyTestFile = testFolder.getFile(TEST_EMPTYFILE_NAME);
// emptyTestFile.create(getContents(FILE_CONTENTS_EMPTY), true,
// getMonitor());
// changes++;
//
// assertTrue("Need to make at least the minimum number of changes",
// changes >= NUM_CHANGES);
// assertFalse("Operation should be invalid", op2.canUndo());
// }
//
// public void testProjectCopyUndoInvalid() throws ExecutionException,
// CoreException {
// // Create a new copy of a project
// CopyProjectOperation op = new CopyProjectOperation(testProject,
// TEST_NEWPROJECT_NAME, null, "testProjectCopyUndoInvalid");
// execute(op);
// // Now we "back door" delete one of the files in the source project
// emptyTestFile.delete(true, getMonitor());
// // The operation should know that undoing is dangerous
// undoExpectFail(op);
// }
//
// public void test162655() throws ExecutionException, CoreException {
// DeleteResourcesOperation op = new DeleteResourcesOperation(
// new IResource[] { testProject }, "testProjectDelete", false);
// execute(op);
// assertFalse("Project delete failed", testProject.exists());
//
// // recreate outside the scope of undo
// testProject = getWorkspace().getRoot().getProject(TEST_PROJECT_NAME);
// testProject.create(getMonitor());
// testProject.open(getMonitor());
// assertTrue("Project creation failed", testProject.exists());
//
// // Now that project exists again, the undo should fail.
// undoExpectFail(op);
// }
//}